Compile character range patterns in linear time - #8868

#8868 made exhaustiveness checking and match compilation find constants by
hashing, because an expanded char range turned one pattern into thousands
of distinct constants. Char ranges are now one pattern each, so the hash
tables in `Parmatch.filter_all`, `Parmatch.get_mins_pats` and
`Matching.divide`, and the `const_key` that kept their keys consistent with
char/int equality, are removed. A dead `char` check in comparison
specialization goes too: `char` expands to `int` before it.

Review: How much slower do large switches compile? A switch with 1,000 int
or string cases compiles 0.02-0.03 s slower; one with 10,000 int cases takes
6.3 s instead of 3.2 s. Polymorphic variants are unaffected: 10,000 cases
take about 35 s either way, as other quadratic steps dominate.

Review: Does the output change? No. All committed snapshots are
byte-identical, and so is the JS of 1,500 fuzzer programs and the
benchmark switches.

Area: typechecker lambda
Output: unchanged
Formatting: unchanged
Formats: none
PPX: unchanged
Editor: unchanged
Tests: none, because the output is unchanged and existing tests cover the
 behaviour
Measured: best of 3 bsc wall time, with -> without the fast paths: 1,000 int
 cases 0.07 -> 0.09 s; 3,000 int 0.34 -> 0.63 s; 10,000 int 3.23 -> 6.27 s;
 1,000 string 0.04 -> 0.07 s; 3,000 string 0.17 -> 0.52 s; 10,000 string
 1.55 -> 5.38 s; 1,000 polymorphic variant 0.23 -> 0.25 s; 10,000
 polymorphic variant 35.47 -> 36.45 s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JALXUyHhkDqzcB3WuW9Svo
Signed-off-by: Christoph Knittel <ck@cca.io>

#8868 made exhaustiveness checking and match compilation find constants by
hashing, because an expanded char range turned one pattern into thousands
of distinct constants. Char ranges are now one pattern each, so the hash
tables in `Parmatch.filter_all`, `Parmatch.get_mins_pats` and
`Matching.divide`, and the `const_key` that kept their keys consistent with
char/int equality, are removed. A dead `char` check in comparison
specialization goes too: `char` expands to `int` before it.

Review: How much slower do large switches compile? A switch with 1,000 int
or string cases compiles 0.02-0.03 s slower; one with 10,000 int cases takes
6.3 s instead of 3.2 s. Polymorphic variants are unaffected: 10,000 cases
take about 35 s either way, as other quadratic steps dominate.

Review: Does the output change? No. All committed snapshots are
byte-identical, and so is the JS of 1,500 fuzzer programs and the
benchmark switches.

Area: typechecker lambda
Output: unchanged
Formatting: unchanged
Formats: none
PPX: unchanged
Editor: unchanged
Tests: none, because the output is unchanged and existing tests cover the
 behaviour
Measured: best of 3 bsc wall time, with -> without the fast paths: 1,000 int
 cases 0.07 -> 0.09 s; 3,000 int 0.34 -> 0.63 s; 10,000 int 3.23 -> 6.27 s;
 1,000 string 0.04 -> 0.07 s; 3,000 string 0.17 -> 0.52 s; 10,000 string
 1.55 -> 5.38 s; 1,000 polymorphic variant 0.23 -> 0.25 s; 10,000
 polymorphic variant 35.47 -> 36.45 s

Claude-Session: https://claude.ai/code/session_01JALXUyHhkDqzcB3WuW9Svo

Signed-off-by: Christoph Knittel <ck@cca.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Why:
    A character range pattern is expanded into one or-pattern alternative
    per character, and typing, the exhaustiveness and unused-case checks,
    default matrices and switch compilation each took time quadratic in
    the number of alternatives: a range over the CJK block ran out of
    memory (#8866).

Matching modified (character range patterns):
Example:
    let f = c =>
      switch c {
      | '\u{100}' .. '\u{1100}' => 1
      | _ => 0
      }
Before (lambda):
    (let
      (f/1001 =
         (function c/1002
           (catch
             (catch
               (if (|| (>[int] c/1002 4352) (<[int] c/1002 256)) (exit 2)
                 (exit 1))
              with (2) 0)
            with (1) 1)))
      (makeblock module/exports f/1001))
After (lambda):
    (let
      (f/1001 =
         (function c/1002
           (catch
             (catch
               (if (|| (>[int] c/1002 4352) (<[int] c/1002 256)) (exit 2)
                 (exit 1))
              with (2) 0)
            with (1) 1)))
      (makeblock module/exports f/1001))
Before (text): `/usr/bin/time -l bsc` on the example, three runs
            2.22 real         2.03 user         0.18 sys
              1273511936  maximum resident set size
            2.20 real         2.02 user         0.16 sys
              1271463936  maximum resident set size
            2.21 real         2.03 user         0.17 sys
              1273659392  maximum resident set size
After (text): `/usr/bin/time -l bsc` on the example, three runs
            0.02 real         0.02 user         0.00 sys
                25395200  maximum resident set size
            0.02 real         0.02 user         0.00 sys
                25624576  maximum resident set size
            0.03 real         0.02 user         0.00 sys
                25591808  maximum resident set size

Review: Where did the time go? Typing copied the right subtree of each
    nested or-pattern to rename variables even when there are none; the
    checks searched the groups linearly for each row and compared all
    pairs of rows for the default matrix minima; switch compilation found
    each key's cell with `List.find`. Groups, minima and int, char and
    string cells are now found by hashing, and the copy is skipped when
    nothing is renamed.

Review: Does the generated code change? No: #8868 reports byte-identical
    JavaScript and warnings across `tests/tests/src`, the `super_errors`
    fixtures and the runtime.

Re-applies #8868 by @cknitt for illustration.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Cristiano Calcagno <cristianoc@users.noreply.github.com>